This was overlooked before.

This demonstrates currently unsoundness when it comes to assignments via setters

There was a corner case in installAfter where

 - A denotation valid in a single phase got replaced by another one
 - Immediately after, the symbol's denotation would be forced in a previous phase

This somehow landed on a wrong denotation. The problem got apparent when more symbols
underwent a Recheck.updateInfoBetween. The flags field installed by a previous update
somehow was not recognized anymore. Specifically, the following was observed in order:

 1. For a parameter getter (xs in LazyList, file pos-custeom-args/captures/lazylists1.scala)
   the Private flag was suppressed via transformInfo at phase cc.
 2. The denotation of the getter v which was valid in the single phase cc+1 was updated at
    at cc by updateInfoInBetween in Recheck so that the Private flag was re-asserted in cc+1.
 3. Immediately afterwards, the getter's flags was demanded at phase cc.
 4. The Private flag was present, even though it should not be.

The problem was fixed by demanding the denotation of the getter as part of isntallAfter.

Constrain closure parameters and result from expected type before rechecking the closure's
body. This gives more precise types and avoids the spurious duplication of some
variables.

It also avoids the unmotivated special case that we needed before to make tests pass.

Previously, the result of a map could contain duplicates.

I verified that with the current code base this could cause problems only for
capture checking.

This reduces the chance of information loss in capture set
propagation for applications.

Currently not needed (was needed for level checking in other branch),
but kept since it is a useful generalization.

These changes were needed if we wanted to map all capability classes C to C^.
They are a good idea anyway since they make the mapping more robust.

 - Define a notion of ccNestingLevel, which corresponds to the nesting level
   of so called "level owners" relative to each other.
 - The outermost level owner is _root_.
 - Other level owners are classes that are not staticOwners
   and methods that are not constructors.
 - The ccNestingLevel of any symbol is the ccNestingLevel of its closest enclosing
   level owner, or -1 for NoSymbol.
 - Capture set variables are created with a level owner.
 - Capture set variables cannot include elements with higher ccNestingLevels
   than the variable's owner.
 - If level-incorrect elements are attempted to be added to a capture set variable,
   they are instead widened to the underlying capture set.
 - Use addenda mechanism to report level errors

Previously, the ccState property was missing on the context used for printing at phase cc.

Intended as a stop-gap for some (as-seen-from related?) problems
when comparing capture refinements of classes.

Replaces previous unsound rule where `cap` subsumes everything.

Some refined function types are of the form

    (A->B)^{cs} { def apply(x: A): B' = ... }

In this case the capture set `cs` was previously dropped. Now it is printed.

Do it in setup instead of on demand. Advantage: no need to determine
level ownership for externally compiled symbols.